// <copyright file="RhythmicContainer.cs" company="Largo">
// Copyright (c) 2009 All Right Reserved
// </copyright>
// <author> vl </author>
// <email></email>
// <date>2009-01-01</date>
// <summary>Contains ...</summary>

using JetBrains.Annotations;
using System;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;
using System.Text;

namespace LargoCommon.Music
{
    /// <summary>
    /// Rhythmic Container.
    /// </summary>
    public class RhythmicContainer {
        #region Fields
        /// <summary>
        /// Singleton variable.
        /// </summary>
        private static readonly RhythmicContainer InternalSingleton = new RhythmicContainer();
        #endregion

        #region Constructors
        /// <summary>
        /// Initializes a new instance of the <see cref="RhythmicContainer"/> class.
        /// </summary>
        /// <param name="givenRhythmicStructures">The given rhythmic structures.</param>
        public RhythmicContainer(IEnumerable<RhythmicStructure> givenRhythmicStructures) {
            Contract.Requires(givenRhythmicStructures != null);

            this.RhythmicStructures = givenRhythmicStructures;
        }

        /// <summary>
        /// Prevents a default instance of the RhythmicContainer class from being created.
        /// </summary>
        private RhythmicContainer() {
        }
        #endregion

        #region Static properties
        /// <summary>
        /// Gets the ProcessLogger Singleton.
        /// </summary>
        /// <value> Property description. </value>/// 
        public static RhythmicContainer Singleton {
            get {
                Contract.Ensures(Contract.Result<RhythmicContainer>() != null);
                if (InternalSingleton == null) {
                    throw new InvalidOperationException("Singleton Rhythmic Container is null.");
                }

                return InternalSingleton;
            }
        }
        #endregion

        #region Public properties
        /// <summary>
        /// Gets the rhythmic structures.
        /// </summary>
        /// <value>
        /// The rhythmic structures.
        /// </value>
        public IEnumerable<RhythmicStructure> RhythmicStructures { get; }

        /// <summary>
        /// Gets or sets the rhythm of harmony structures.
        /// </summary>
        /// <value>
        /// The rhythm of harmony structures.
        /// </value>
        [UsedImplicitly]
        public IList<RhythmicStructure> RhythmicOfHarmonyStructures { get; set; }   //// CA1044 (FxCop)
        #endregion

        #region Private properties
        /*
        /// <summary>
        /// Gets all variant structures.
        /// </summary>
        /// <value> Property description. </value>
        private IList<RhythmicStructure> AllVariantStructures {
            get {
                //// return null;
                ///// Rhythmic structures ...
                var structs = RegularStructures(this.rhythmicOrder).ToList();
                structs.AddRange(this.Structures);
                structs.AddRange(this.RhythmicOfHarmonyStructures);

                var sortedStructs = (from str in structs
                                     orderby str.Mobility ascending, str.ElementSchema descending
                                     where str != null
                                     select str).Distinct().ToList();

                return sortedStructs;
            }
        }
   
        /// <summary>
        /// Gets the common structures.
        /// </summary>
        /// <value> Property description. </value>
        private IList<RhythmicStructure> CommonStructures {
            get {
                var structs = this.SegmentOfStructures(3, 0);
                return structs;
            }
        }
        
   
        /// <summary>
        /// Gets the mean structures.
        /// </summary>
        /// <value> Property description. </value>
        private IList<RhythmicStructure> MeanStructures {
            get {
                var structs = this.SegmentOfStructures(3, 1);
                return structs;
            }
        }

        /// <summary>
        /// Gets the rare structures.
        /// </summary>
        /// <value> Property description. </value>
        private IList<RhythmicStructure> RareStructures {
            get {
                var structs = this.SegmentOfStructures(3, 2);
                return structs;
            }
        }

        /// <summary>
        /// Gets or sets the structures.
        /// </summary>
        /// <value>
        /// The structures.
        /// </value>
        private IList<RhythmicStructure> Structures { get; set; }
     */
        #endregion

        #region Static methods
        /// <summary>
        /// Gets the regular structures.
        /// </summary>
        /// <param name="givenRhythmicOrder">The given rhythmic order.</param>
        /// <returns>
        /// Returns value.
        /// </returns>
        /// <value> Property description. </value>
        public static IList<RhythmicStructure> RegularStructures(byte givenRhythmicOrder)
        {
            var structs = new List<RhythmicStructure>();
            for (var parts = 1; parts < givenRhythmicOrder - 1; parts++)
            {
                if (parts > 16 || givenRhythmicOrder % parts != 0)
                {
                    continue;
                }

                var rms = RegularRhythmicStructure(givenRhythmicOrder, parts);
                structs.Add(rms);
            }

            return structs;
        }
        #endregion

        /// <summary> Gets grouped rhythmic structures. </summary>
        /// <param name="givenModel"> The given model. </param>
        /// <param name="givenBlock"> The given block. </param>
        /// <returns> The grouped rhythmic structures. </returns>
        public IList<RhythmicStructure> GetGroupedRhythmicStructures(RhythmicModel givenModel, MusicalBlock givenBlock) {
            var rhythmicMaterial = givenModel.ExtractRhythmicMaterial();

            var list = (from s in rhythmicMaterial.Structures
                        orderby s.ToneLevel descending, s.FormalBehavior.Variance ascending, s.Occurrence descending
                        select s).ToList();

            //// Regular structures.
            var regular = RegularStructures(givenModel.RhythmicOrder); //// Header.System.RhythmicOrder
            list.AddRange(regular);

            //// Structures from harmony.
            if (givenBlock != null) {
                var tmplist = new List<RhythmicStructure>();
                foreach (var bar in givenBlock.Body.Bars) {
                    var structure = bar?.HarmonicBar?.RhythmicStructure;
                    if (structure == null) {
                        continue;
                    }

                    tmplist.Add(structure);
                }

                list.AddRange(tmplist);
            }

            //// Grouping
            IList<RhythmicStructure> structures = new List<RhythmicStructure>();
            var groupList = (from ms in list
                             group ms by ms.GetStructuralCode into g
                             select g).ToList();
            foreach (var g in groupList) {
                var s = g.FirstOrDefault();
                if (s == null) {
                    continue;
                }

                var ms = s;  //// Clone? //// new RhythmicStructure(s.RhythmicSystem, s.GetStructuralCode())
                ms.Occurrence = g.Count();
                ms.DetermineLevel(); //// 2019/01
                ms.DetermineBehavior(); //// 2019/01
                structures.Add(ms);
            }

            return structures;
        }

        #region Public methods - Find rhythmic structures
        /// <summary>
        /// Rhythmic structure.
        /// </summary>
        /// <param name="energyChange">The energy change.</param>
        /// <returns>
        /// Returns value.
        /// </returns>
        [UsedImplicitly]
        public RhythmicStructure FindRhythmicStructure(EnergyChange energyChange) {
            RhythmicStructure optimalStructure = null;
            float bestValue = +10000;
            foreach (var structure in this.RhythmicStructures) {
                var value = Math.Abs(structure.Level - energyChange.BeatLevel)
                              + Math.Abs(structure.ToneLevel - energyChange.ToneLevel)
                              + Math.Abs(structure.FormalBehavior.Variance - energyChange.RhythmicTension);
                if (value >= bestValue) {
                    continue;
                }

                bestValue = value;
                optimalStructure = structure;
            }

            return optimalStructure;
        }

        /// <summary>
        /// Finds the similar structure.
        /// </summary>
        /// <param name="givenStruct">The given struct.</param>
        /// <returns>
        /// Returns value.
        /// </returns>
        [UsedImplicitly]
        public RhythmicStructure FindSimilarStructure(RhythmicStructure givenStruct) {
            Contract.Requires(givenStruct != null);

            RhythmicStructure optimalStruct = null;
            float minimumResult = 1000;

            //// rstruct.DetermineBehavior();
            foreach (var rstruct in this.RhythmicStructures) { //// 1000
                if (rstruct.ElementSchema == givenStruct.ElementSchema) {
                    continue;
                }

                var s = rstruct.SimilarityValue(givenStruct);
                if (s > 90) {
                    continue;
                }

                var level = givenStruct.Level + rstruct.Level > 0 ?
                            100.0f * 2 * Math.Abs(givenStruct.Level - rstruct.Level) / (givenStruct.Level + rstruct.Level)
                            : 0;
                var toneLevel = givenStruct.ToneLevel + rstruct.ToneLevel > 0 ?
                            100.0f * 2 * Math.Abs(givenStruct.ToneLevel - rstruct.ToneLevel) / (givenStruct.ToneLevel + rstruct.ToneLevel)
                            : 0;

                var variance = Math.Abs(givenStruct.FormalBehavior.Variance - rstruct.FormalBehavior.Variance);
                var balance = Math.Abs(givenStruct.FormalBehavior.Balance - rstruct.FormalBehavior.Balance);
                //// float beat = Math.Abs(givenStruct.Beat - rstruct.Beat);
                //// float filling = Math.Abs(givenStruct.Filling - rstruct.Filling);
                //// float complexity = Math.Abs(givenStruct.Complexity - rstruct.Complexity);

                var result = (4 * toneLevel) + (2 * level) + variance + balance;
                if (result >= minimumResult) {
                    continue;
                }

                optimalStruct = rstruct;
                minimumResult = result;
            }

            return optimalStruct;
        }
        #endregion

        #region String representation
        /// <summary> String representation of the object. </summary>
        /// <returns> Returns value. </returns>
        public override string ToString() {
            return "RhythmicContainer";
        }
        #endregion

        #region Public methods
        /// <summary>
        /// Gets the structures.
        /// </summary>
        /// <returns>
        /// Returns value.
        /// </returns>
        public IEnumerable<RhythmicStructure> GetStructures() { 
            return null;
            /* Rhythmic structures ...
            var structures = new List<RhythmicStructure>();
            switch (listIndex) {
                case 0: {
                        structures = (List<RhythmicStructure>)this.AllVariantStructures;
                        break;
                    }

                case 1: {
                        structures = (List<RhythmicStructure>)this.CommonStructures;
                        break;
                    }

                case 2: {
                        structures = (List<RhythmicStructure>)this.MeanStructures;
                        break;
                    }

                case 3: {
                        structures = (List<RhythmicStructure>)this.RareStructures;
                        break;
                    }

                case 4: {
                        structures = (List<RhythmicStructure>)RegularStructures(this.rhythmicOrder);
                        break;
                    }

                case 5: {
                        structures = (List<RhythmicStructure>)this.RhythmicOfHarmonyStructures;
                        break;
                    }
            }

            if (structures == null) {
                return null;
            }

            var distinctList = structures
                                .GroupBy(s => s.ElementSchema)
                                .Select(g => g.First())
                                .ToList();

            var sortedList = (from s in distinctList 
                              orderby s.Level, s.ToneLevel 
                              select s).ToList();
            return sortedList; */
        }

        /// <summary>
        /// Prepares the rhythmic structures.
        /// </summary>
        /// <param name="totalNumber">The total number.</param>
        /// <param name="includeInversions">If set to <c>true</c> [include inversions].</param>
        /// <returns>
        /// Returns value.
        /// </returns>
        [UsedImplicitly]
        public IList<RhythmicStructure> LeadingStructures(int totalNumber, bool includeInversions) {
            var structures = new List<RhythmicStructure>();
            /*
            var number = 0;
            var commonStructs = LeadingStructures(totalNumber, includeInversions, this.CommonStructures, ref number);
            structures.AddRange(commonStructs);

            var meanStructs = LeadingStructures(totalNumber, includeInversions, this.MeanStructures, ref number);
            structures.AddRange(meanStructs);
            */
            return structures;
        }
        #endregion

        #region Private static methods - Regular structures      

        /// <summary>
        /// Regulars the rhythmic structure.
        /// </summary>
        /// <param name="givenRhythmicOrder">The given rhythmic order.</param>
        /// <param name="parts">The parts.</param>
        /// <returns>
        /// Returns value.
        /// </returns>
        private static RhythmicStructure RegularRhythmicStructure(byte givenRhythmicOrder, int parts)
        {
            var rs = RhythmicSystem.GetRhythmicSystem(RhythmicDegree.Structure, givenRhythmicOrder);

            var sb = new StringBuilder();
            var length = givenRhythmicOrder / parts;
            var s = string.Format(CultureInfo.CurrentCulture, "1,{0}*0,", length - 1);
            for (var i = 0; i < parts; i++) {
                sb.Append(s);
            }

            sb.Remove(sb.Length - 1, 1);
            var rms = new RhythmicStructure(rs, sb.ToString());

            return rms;
        } 
        #endregion

 #region Private methods
        /*
            /// <summary>
            /// Leading structures.
            /// </summary>
            /// <param name="totalNumber">The total number.</param>
            /// <param name="includeInversions">If set to <c>true</c> [include inversions].</param>
            /// <param name="common">The common.</param>
            /// <param name="number">The number.</param>
            /// <returns> Returns value. </returns>
            private static IEnumerable<RhythmicStructure> LeadingStructures(int totalNumber, bool includeInversions, IList<RhythmicStructure> common, ref int number) {
                var structures = new List<RhythmicStructure>();
                structures.AddRange(common.Take(number));
                number += structures.Count;

                foreach (var rstruct in common) {
                    // ReSharper disable once InvertIf
                    if (includeInversions) {
                        var invertedStructure = rstruct.InvertedStructure();
                        structures.Add(invertedStructure);
                        if (number >= totalNumber) {
                            break;
                        }
                    }
                }

                return structures;
            }

            /// <summary>
            /// Segments the of structures.
            /// </summary>
            /// <param name="classCount">The class count.</param>
            /// <param name="classNumber">The class number.</param>
            /// <returns> Returns value. </returns>
            private List<RhythmicStructure> SegmentOfStructures(int classCount, int classNumber) {
                var modelStructs = this.Structures;
                var cnt = modelStructs.Count;
                var number = (int)(1.0f * cnt / classCount);
                var start = number * classNumber;
                var structs = (from str in modelStructs
                               orderby str.Occurrence descending, str.Level ascending, str.ToneLevel ascending
                               select str)
                    .Skip(start)
                    .Take(number).ToList();
                return structs;
            } */
        #endregion
    }
}